This magazine is dedicated to exploration of other techniques available for Microsoft Word Macro Virus propagation.
First:
It is possible to propagate macros other than with the standard MacroCopy command. It is possible to use the ToolsMacro. Edit command to create a new macro and then insert text into it directly. The text can be copied out of the creating macro using LineUp, LineDown, CharLeft, and CharRight commands with the X, 1 flag set to select the desired text. Follow this with an EditCopy command and the EditPaste in the "blank" macro and you have created a macro without using the MacroCopy command.
This functionality allows you to store all of your macros in one single macro while in "transit" (an infected document) and to "extract" the macros upon delivery to the target (NORMAL.DOT to be infected), including your stealth macros (unless, of course, your stealth macros ARE the infection vector).
(see example virus)
Second:
More Mutation: Using the above technique as a starting point, it is possible to create better mutation than just mutating macro names. It is in fact possible to create mutating variable names and mutating Sub/Function names.
To do so, it is imperative that your code knows exactly where and long the variable/routine-name to be mutated is (at least one sample of it). If you know that one location in a macro will never change, you can use that. Then, you can read in the fixed length name with the GetText$(X,X) command. Now, run your random name generator (making certain to generate a name that is THE SAME LENGTH). Finally, use the EditReplace command to swap out all of the old names for the new names. (see example virus)
You could also keep a separate "dummy" macro or routine that just stores a list of your ever mutating variable names so that you could have mutating lengths as well. That way, you could just read in the first line in the list as your current variable, mutate it, then do your global replace, then move on to the next in your list.
i.e.:
sub dummy
LKJIIEKDG < ---- first variable
LKJS
LKJSOALKJBIEWDLA
POIEWM
SIEFQZCVWT
YJFHBWPVU < -----last variable
end sub
Third:
Even More Mutation: Using a combination of the above techniques, it is possible to create mutating code segments. That is, segments of code that change locations within the body of the code.
Consider if you will: You could create a macro with several subroutines of exactly the same length. Then when it was time to mutate (say at the next document infection), just use your knowledge that your have three subroutines of exactly the same length, starting at line X below the calling routine, and jumble them around.
i.e.
sub Main
segmentA
segmentB
segmentC
end sub
sub segmentA
do some stuff
end sub
sub segmentB
do some other stuff
end sub
sub segmentC
do strange stuff
end sub
could become:
sub Main
segmentA
segmentB
segmentC
end sub
sub segmentB
do some other stuff
end sub
sub segmentC
do strange stuff
end sub
sub segmentA
do some stuff
end sub
or it could become:
sub Main
segmentA
segmentB
segmentC
end sub
sub segmentB
do some other stuff
end sub
sub segmentA
do some stuff
end sub
sub segmentC
do strange stuff
end sub
Or it could become ANY permutation in the set! Plus, the more subroutines you have to "jumble," the better the mutation becomes!
Fourth:
The future? Only you can determine what's in the future. Be creative!
